home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / AGNUS / SRC / SYSINFO / XHDI.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-16  |  6.7 KB  |  350 lines
  1. /*
  2.     @(#)XHDI/xhdi.c
  3.     
  4.     Julian F. Reschke, 15. Mai 1993
  5.     
  6.     Bindings for the XHDI functions
  7.     --- NOT FULLY TESTED, USE AT YOUR OWN RISK ---
  8.  
  9.     Important:
  10.     
  11.     Do calls only if XHGetVersion() was successful
  12. */
  13.  
  14. #include <stddef.h>
  15. #include <stdio.h>
  16. #include <string.h>
  17. #ifdef __GNUC__
  18. # include <ostruct.h>
  19. # include <osbind.h>
  20. #else
  21. # include <tos.h>
  22. #endif
  23.  
  24. #include "xhdi.h"
  25.  
  26. #define XHDIMAGIC 0x27011992L
  27. #define _XHDI    0x58484449L
  28.  
  29. typedef LONG cdecl (*cookie_fun)(UWORD opcode,...);
  30.  
  31. static long
  32. cookieptr (void)
  33. {
  34.     return *((long *)0x5a0);
  35. }
  36.  
  37. static int
  38. getcookie (long cookie, long *p_value)
  39. {
  40.     long *cookiejar = (long *)Supexec (cookieptr);
  41.  
  42.     if (!cookiejar) return 0;
  43.  
  44.     do
  45.     {
  46.         if (cookiejar[0] == cookie)
  47.         {
  48.             if (p_value) *p_value = cookiejar[1];
  49.             return 1;
  50.         }
  51.         else
  52.             cookiejar = &(cookiejar[2]);
  53.     } while (cookiejar[-2]);
  54.  
  55.     return 0;
  56. }
  57.  
  58. static cookie_fun
  59. get_fun_ptr (void)
  60. {
  61.     static cookie_fun XHDI = NULL;
  62.     static int have_it = 0;
  63.     
  64.     if (!have_it)
  65.     {
  66.         LONG *magic_test;
  67.     
  68.         getcookie (_XHDI, (LONG *)&XHDI);
  69.         have_it = 1;
  70.  
  71.         /* check magic */
  72.         
  73.         magic_test = (LONG *)XHDI;
  74.         if (magic_test && (magic_test[-1] != XHDIMAGIC))
  75.             XHDI = NULL;
  76.     }
  77.     
  78.     return XHDI;
  79. }
  80.  
  81.  
  82. UWORD
  83. XHGetVersion (void)
  84. {
  85.     cookie_fun XHDI = get_fun_ptr ();
  86.     LONG oldstack = 0;
  87.     UWORD ret = 0;        /* 0: kein Cookie da */
  88.  
  89.     if (!Super ((void *)1L)) oldstack = Super (0L);
  90.     
  91.     if (XHDI)
  92.         ret = (UWORD) XHDI (0);
  93.         
  94.     if (oldstack) Super ((void *)oldstack);
  95.     return ret;
  96. }
  97.  
  98. LONG
  99. XHInqTarget (UWORD major, UWORD minor, ULONG *block_size,
  100.              ULONG *device_flags, char *product_name)
  101. {
  102.     cookie_fun XHDI = get_fun_ptr ();
  103.     LONG oldstack = 0;
  104.     LONG ret;
  105.     
  106.     if (!Super ((void *)1L)) oldstack = Super (0L);
  107.     
  108.     ret = XHDI (1, major, minor, block_size, device_flags,
  109.                 product_name);
  110.         
  111.     if (oldstack) Super ((void *)oldstack);
  112.     return ret;
  113. }
  114.  
  115. LONG
  116. XHReserve (UWORD major, UWORD minor, UWORD do_reserve, UWORD key)
  117. {
  118.     cookie_fun XHDI = get_fun_ptr ();
  119.     LONG oldstack = 0;
  120.     LONG ret;
  121.     
  122.     if (!Super ((void *)1L)) oldstack = Super (0L);
  123.     
  124.     ret = XHDI (2, major, minor, do_reserve, key);
  125.         
  126.     if (oldstack) Super ((void *)oldstack);
  127.     return ret;
  128. }
  129.  
  130. LONG
  131. XHLock (UWORD major, UWORD minor, UWORD do_lock, UWORD key)
  132. {
  133.     cookie_fun XHDI = get_fun_ptr ();
  134.     LONG oldstack = 0;
  135.     LONG ret;
  136.     
  137.     if (!Super ((void *)1L)) oldstack = Super (0L);
  138.     
  139.     ret = XHDI (3, major, minor, do_lock, key);
  140.         
  141.     if (oldstack) Super ((void *)oldstack);
  142.     return ret;
  143. }
  144.  
  145. LONG
  146. XHStop (UWORD major, UWORD minor, UWORD do_stop, UWORD key)
  147. {
  148.     cookie_fun XHDI = get_fun_ptr ();
  149.     LONG oldstack = 0;
  150.     LONG ret;
  151.     
  152.     if (!Super ((void *)1L)) oldstack = Super (0L);
  153.     
  154.     ret = XHDI (4, major, minor, do_stop, key);
  155.         
  156.     if (oldstack) Super ((void *)oldstack);
  157.     return ret;
  158. }
  159.  
  160. LONG
  161. XHEject (UWORD major, UWORD minor, UWORD do_eject, UWORD key)
  162. {
  163.     cookie_fun XHDI = get_fun_ptr ();
  164.     LONG oldstack = 0;
  165.     LONG ret;
  166.     
  167.     if (!Super ((void *)1L)) oldstack = Super (0L);
  168.     
  169.     ret = XHDI (5, major, minor, do_eject, key);
  170.         
  171.     if (oldstack) Super ((void *)oldstack);
  172.     return ret;
  173. }
  174.  
  175. ULONG
  176. XHDrvMap (void)
  177. {
  178.     cookie_fun XHDI = get_fun_ptr ();
  179.     LONG oldstack = 0;
  180.     LONG ret;
  181.     
  182.     if (!Super ((void *)1L)) oldstack = Super (0L);
  183.     
  184.     ret = XHDI (6);
  185.         
  186.     if (oldstack) Super ((void *)oldstack);
  187.     return ret;
  188. }
  189.  
  190. LONG
  191. XHInqDev (UWORD bios_device, UWORD *major, UWORD *minor,
  192.           ULONG *start_sector, BPB *bpb)
  193. {
  194.     cookie_fun XHDI = get_fun_ptr ();
  195.     LONG oldstack = 0;
  196.     LONG ret;
  197.     
  198.     if (!Super ((void *)1L)) oldstack = Super (0L);
  199.     
  200.     ret = XHDI (7, bios_device, major, minor, start_sector, bpb);
  201.         
  202.     if (oldstack) Super ((void *)oldstack);
  203.     return ret;
  204. }
  205.  
  206. LONG
  207. XHInqDriver (UWORD bios_device, char *name, char *version,
  208.     char *company, UWORD *ahdi_version, UWORD *maxIPL)
  209. {
  210.     cookie_fun XHDI = get_fun_ptr ();
  211.     LONG oldstack = 0;
  212.     LONG ret;
  213.     
  214.     if (!Super ((void *)1L)) oldstack = Super (0L);
  215.     
  216.     ret = XHDI (8, bios_device, name, version, company, ahdi_version,
  217.                 maxIPL);
  218.  
  219.     if (oldstack) Super ((void *)oldstack);
  220.     return ret;
  221. }
  222.  
  223. LONG
  224. XHNewCookie (void *newcookie)
  225. {
  226.     cookie_fun XHDI = get_fun_ptr ();
  227.     LONG oldstack = 0;
  228.     LONG ret;
  229.     
  230.     if (!Super ((void *)1L)) oldstack = Super (0L);
  231.     
  232.     ret = XHDI (9, newcookie);
  233.         
  234.     if (oldstack) Super ((void *)oldstack);
  235.     return ret;
  236. }
  237.  
  238. LONG
  239. XHReadWrite (UWORD major, UWORD minor, UWORD rwflag,
  240.              ULONG recno, UWORD count, void *buf)
  241. {
  242.     cookie_fun XHDI = get_fun_ptr ();
  243.     LONG oldstack = 0;
  244.     LONG ret;
  245.     
  246.     if (!Super ((void *)1L)) oldstack = Super (0L);
  247.     
  248.     ret = XHDI (10, major, minor, rwflag, recno, count, buf);
  249.  
  250.     if (oldstack) Super ((void *)oldstack);
  251.     return ret;
  252. }
  253.  
  254. LONG
  255. XHInqTarget2 (UWORD major, UWORD minor, ULONG *block_size,
  256.               ULONG *device_flags, char *product_name,
  257.               UWORD stringlen)
  258. {
  259.     cookie_fun XHDI = get_fun_ptr ();
  260.     LONG oldstack = 0;
  261.     LONG ret;
  262.     
  263.     if (!Super ((void *)1L)) oldstack = Super (0L);
  264.     
  265.     ret = XHDI (11, major, minor, block_size, device_flags,
  266.                 product_name, stringlen);
  267.         
  268.     if (oldstack) Super ((void *)oldstack);
  269.     return ret;
  270. }
  271.  
  272. LONG
  273. XHInqDev2 (UWORD bios_device, UWORD *major, UWORD *minor,
  274.            ULONG *start_sector, BPB *bpb, ULONG *blocks,
  275.            char *partid)
  276. {
  277.     cookie_fun XHDI = get_fun_ptr ();
  278.     LONG oldstack = 0;
  279.     LONG ret;
  280.     
  281.     if (!Super ((void *)1L)) oldstack = Super (0L);
  282.     
  283.     ret = XHDI (12, bios_device, major, minor, start_sector, bpb,
  284.                 blocks, partid);
  285.         
  286.     if (oldstack) Super ((void *)oldstack);
  287.     return ret;
  288. }
  289.  
  290. LONG
  291. XHDriverSpecial (ULONG key1, ULONG key2, UWORD subopcode, void *data)
  292. {
  293.     cookie_fun XHDI = get_fun_ptr ();
  294.     LONG oldstack = 0;
  295.     LONG ret;
  296.     
  297.     if (!Super ((void *)1L)) oldstack = Super (0L);
  298.     
  299.     ret = XHDI (13, key1, key2, subopcode, data);
  300.         
  301.     if (oldstack) Super ((void *)oldstack);
  302.     return ret;
  303. }
  304.  
  305. LONG
  306. XHGetCapacity (UWORD major, UWORD minor, ULONG *blocks, ULONG *bs)
  307. {
  308.     cookie_fun XHDI = get_fun_ptr ();
  309.     LONG oldstack = 0;
  310.     LONG ret;
  311.     
  312.     if (!Super ((void *)1L)) oldstack = Super (0L);
  313.     
  314.     ret = XHDI (14, major, minor, blocks, bs);
  315.         
  316.     if (oldstack) Super ((void *)oldstack);
  317.     return ret;
  318. }
  319.  
  320. void
  321. XHMakeName (UWORD major, UWORD minor, ULONG start_sector, char *name)
  322. {
  323.     if (major < 8)
  324.     {
  325.         sprintf (name, "ACSI.%d.%d.%ld", major, minor, start_sector);
  326.         return;
  327.     }    
  328.  
  329.     if (major < 16)
  330.     {
  331.         sprintf (name, "SCSI.%d.%d.%ld", major - 8, minor,
  332.             start_sector);
  333.         return;
  334.     }    
  335.  
  336.     if (major < 18)
  337.     {
  338.         sprintf (name, "IDE.%d.%ld", major - 16, start_sector);
  339.         return;
  340.     }    
  341.  
  342.     if (major == 64)
  343.     {
  344.         sprintf (name, "FD.%d.%ld", minor, start_sector);
  345.         return;
  346.     }    
  347.     
  348.     sprintf (name, "XHDI.%d.%d.%ld", major, minor, start_sector);
  349. }
  350.